ജാവാസ്ക്രിപ്റ്റ് പ്രൈവറ്റ് മെത്തേഡ് ഡെക്കറേറ്ററുകൾ: ക്ലാസ് മെച്ചപ്പെടുത്തലിൻ്റെയും വാലിഡേഷൻ്റെയും ഒരു ആഴത്തിലുള്ള പഠനം

ആധുനിക ജാവാസ്ക്രിപ്റ്റ് നിരന്തരമായ പരിണാമത്തിലാണ്, കൂടുതൽ പ്രകടിപ്പിക്കാവുന്നതും പരിപാലിക്കാൻ എളുപ്പമുള്ളതും കരുത്തുറ്റതുമായ കോഡ് എഴുതാൻ ഡെവലപ്പർമാരെ സഹായിക്കുന്ന പുതിയ സവിശേഷതകൾ കൊണ്ടുവരുന്നു. ഇവയിൽ ഏറ്റവും പ്രതീക്ഷയോടെ കാത്തിരിക്കുന്ന ഒന്നാണ് ഡെക്കറേറ്ററുകൾ. ടിസി39 പ്രോസസ്സിൽ സ്റ്റേജ് 3-ൽ എത്തിയതോടെ, ഡെക്കറേറ്ററുകൾ ഭാഷയുടെ ഒരു അടിസ്ഥാന ഭാഗമാകാൻ പോകുകയാണ്, കൂടാതെ മെറ്റാപ്രോഗ്രാമിംഗിനെയും ക്ലാസ്-ബേസ്ഡ് ആർക്കിടെക്ചറിനെയും നാം സമീപിക്കുന്ന രീതിയിൽ വിപ്ലവം സൃഷ്ടിക്കുമെന്ന് അവ വാഗ്ദാനം ചെയ്യുന്നു.

ക്ലാസിലെ വിവിധ ഘടകങ്ങളിൽ ഡെക്കറേറ്ററുകൾ പ്രയോഗിക്കാമെങ്കിലും, ഈ ലേഖനം ഒരു പ്രത്യേക ശക്തമായ പ്രയോഗത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു: പ്രൈവറ്റ് മെത്തേഡ് ഡെക്കറേറ്ററുകൾ. ഈ പ്രത്യേക ഡെക്കറേറ്ററുകൾ നമ്മുടെ ക്ലാസുകളുടെ ആന്തരിക പ്രവർത്തനങ്ങൾ എങ്ങനെ മെച്ചപ്പെടുത്താനും സാധൂകരിക്കാനും അനുവദിക്കുന്നുവെന്ന് നമ്മൾ പര്യവേക്ഷണം ചെയ്യും, ഇത് യഥാർത്ഥ എൻക്യാപ്‌സുലേഷൻ പ്രോത്സാഹിപ്പിക്കുകയും ശക്തവും പുനരുപയോഗിക്കാവുന്നതുമായ പെരുമാറ്റങ്ങൾ ചേർക്കുകയും ചെയ്യുന്നു. ആഗോള തലത്തിൽ സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകളും ലൈബ്രറികളും ഫ്രെയിംവർക്കുകളും നിർമ്മിക്കുന്നതിനുള്ള ഒരു ഗെയിം ചേഞ്ചറാണിത്.

അടിസ്ഥാനങ്ങൾ: എന്താണ് യഥാർത്ഥത്തിൽ ഡെക്കറേറ്ററുകൾ?

അടിസ്ഥാനപരമായി, ഡെക്കറേറ്ററുകൾ ഒരുതരം മെറ്റാപ്രോഗ്രാമിംഗ് ആണ്. ലളിതമായി പറഞ്ഞാൽ, മറ്റ് ഫംഗ്ഷനുകളെയോ ക്ലാസുകളെയോ പ്രോപ്പർട്ടികളെയോ പരിഷ്കരിക്കുന്ന പ്രത്യേക തരം ഫംഗ്ഷനുകളാണ് അവ. അവയുടെ പ്രധാന നിർവ്വഹണത്തിൽ മാറ്റം വരുത്താതെ കോഡ് ഘടകങ്ങളിലേക്ക് സ്വഭാവം ചേർക്കുന്നതിന് @expression ഫോർമാറ്റ് ഉപയോഗിച്ച് ഒരു ഡിക്ലറേറ്റീവ് സിൻ്റാക്സ് അവ നൽകുന്നു.

ഇതിനെ പ്രവർത്തനത്തിൻ്റെ പാളികൾ ചേർക്കുന്നത് പോലെ ചിന്തിക്കുക. നിങ്ങളുടെ പ്രധാന ബിസിനസ്സ് ലോജിക്ക് ലോഗിംഗ്, ടൈമിംഗ്, അല്ലെങ്കിൽ വാലിഡേഷൻ പോലുള്ള കാര്യങ്ങൾ കൊണ്ട് സങ്കീർണ്ണമാക്കുന്നതിന് പകരം, ഒരു മെത്തേഡിനെ ഈ കഴിവുകൾ ഉപയോഗിച്ച് 'അലങ്കരിക്കാൻ' കഴിയും. ഇത് ആസ്പെക്റ്റ്-ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗ് (AOP), സിംഗിൾ റെസ്പോൺസിബിലിറ്റി പ്രിൻസിപ്പിൾ തുടങ്ങിയ ശക്തമായ സോഫ്റ്റ്‌വെയർ എഞ്ചിനീയറിംഗ് തത്വങ്ങളുമായി യോജിക്കുന്നു, അവിടെ ഒരു ഫംഗ്ഷനോ ക്ലാസ്സിനോ മാറാൻ ഒരു കാരണം മാത്രമേ ഉണ്ടാകാവൂ.

ഡെക്കറേറ്ററുകൾ ഇവയിൽ പ്രയോഗിക്കാം:

• ക്ലാസുകൾ
• മെത്തേഡുകൾ (പബ്ലിക്, പ്രൈവറ്റ്)
• ഫീൽഡുകൾ (പബ്ലിക്, പ്രൈവറ്റ്)
• അക്സസറുകൾ (ഗെറ്ററുകൾ/സെറ്ററുകൾ)

ഇന്ന് നമ്മുടെ ശ്രദ്ധ ഡെക്കറേറ്ററുകളും മറ്റൊരു ആധുനിക ജാവാസ്ക്രിപ്റ്റ് സവിശേഷതയുമായ പ്രൈവറ്റ് ക്ലാസ് മെമ്പർമാരും ചേർന്നുള്ള ശക്തമായ സംയോജനത്തിലാണ്.

ഒരു മുൻ വ്യവസ്ഥ: പ്രൈവറ്റ് ക്ലാസ് സവിശേഷതകൾ മനസ്സിലാക്കൽ

ഒരു പ്രൈവറ്റ് മെത്തേഡിനെ ഫലപ്രദമായി അലങ്കരിക്കുന്നതിന് മുമ്പ്, അതിനെ പ്രൈവറ്റ് ആക്കുന്നത് എന്താണെന്ന് നമ്മൾ മനസ്സിലാക്കണം. വർഷങ്ങളായി, ജാവാസ്ക്രിപ്റ്റ് ഡെവലപ്പർമാർ അടിവര പ്രിഫിക്‌സ് (ഉദാ: `_myPrivateMethod`) പോലുള്ള കീഴ്‌വഴക്കങ്ങൾ ഉപയോഗിച്ച് പ്രൈവസി അനുകരിച്ചിരുന്നു. എന്നിരുന്നാലും, ഇത് ഒരു കീഴ്‌വഴക്കം മാത്രമായിരുന്നു; ആ മെത്തേഡ് പൊതുവായി ലഭ്യമായിരുന്നു.

ആധുനിക ജാവാസ്ക്രിപ്റ്റ് ഒരു ഹാഷ് പ്രിഫിക്‌സ് (`#`) ഉപയോഗിച്ച് യഥാർത്ഥ പ്രൈവറ്റ് ക്ലാസ് അംഗങ്ങളെ അവതരിപ്പിച്ചു.

ഈ ക്ലാസ് പരിഗണിക്കുക:

            
class PaymentGateway {
  #apiKey;

  constructor(apiKey) {
    this.#apiKey = apiKey;
  }

  #createAuthHeader() {
    // Internal logic to create a secure header
    // This should never be called from outside the class
    const timestamp = Date.now();
    return `API-Key ${this.#apiKey}:${timestamp}`;
  }

  submitPayment(data) {
    const headers = this.#createAuthHeader();
    console.log('Submitting payment with header:', headers);
    // ... fetch call to the payment API
  }
}

const gateway = new PaymentGateway('my-secret-key');

// This works as intended
gateway.submitPayment({ amount: 100 });

// This will throw a SyntaxError or TypeError
// gateway.#createAuthHeader(); // Error: Private field '#createAuthHeader' must be declared in an enclosing class

            

              
                Copy
              
            
          

`#createAuthHeader` മെത്തേഡ് ശരിക്കും പ്രൈവറ്റ് ആണ്. `PaymentGateway` ക്ലാസിനുള്ളിൽ നിന്ന് മാത്രമേ ഇത് ആക്സസ് ചെയ്യാൻ കഴിയൂ, ഇത് ശക്തമായ എൻക്യാപ്‌സുലേഷൻ ഉറപ്പാക്കുന്നു. പ്രൈവറ്റ് മെത്തേഡ് ഡെക്കറേറ്ററുകൾ നിർമ്മിക്കുന്നതിൻ്റെ അടിസ്ഥാനം ഇതാണ്.

ഒരു പ്രൈവറ്റ് മെത്തേഡ് ഡെക്കറേറ്ററിൻ്റെ ഘടന

ഒരു പ്രൈവറ്റ് മെത്തേഡിനെ അലങ്കരിക്കുന്നത് പബ്ലിക് മെത്തേഡിനെ അലങ്കരിക്കുന്നതിൽ നിന്ന് അല്പം വ്യത്യസ്തമാണ്, കാരണം അതിൻ്റെ സ്വകാര്യത തന്നെ. ഡെക്കറേറ്ററിന് മെത്തേഡ് ഫംഗ്ഷൻ നേരിട്ട് ലഭിക്കുന്നില്ല. പകരം, അതിന് ടാർഗെറ്റ് മൂല്യവും പ്രൈവറ്റ് അംഗവുമായി സുരക്ഷിതമായി സംവദിക്കാൻ സഹായിക്കുന്ന ഒരു `context` ഒബ്‌ജക്റ്റും ലഭിക്കുന്നു.

ഒരു മെത്തേഡ് ഡെക്കറേറ്റർ ഫംഗ്ഷൻ്റെ സിഗ്നേച്ചർ ഇതാണ്: function(target, context)

• `target`: മെത്തേഡ് ഫംഗ്ഷൻ തന്നെ (പബ്ലിക് മെത്തേഡുകൾക്ക്) അല്ലെങ്കിൽ പ്രൈവറ്റ് മെത്തേഡുകൾക്ക് `undefined` ആയിരിക്കും. പ്രൈവറ്റ് മെത്തേഡുകൾക്കായി, മെത്തേഡ് ആക്സസ് ചെയ്യാൻ നമ്മൾ `context` ഒബ്‌ജക്റ്റ് ഉപയോഗിക്കണം.
• `context`: അലങ്കരിച്ച ഘടകത്തെക്കുറിച്ചുള്ള മെറ്റാഡാറ്റ അടങ്ങിയ ഒരു ഒബ്‌ജക്റ്റ്. ഒരു പ്രൈവറ്റ് മെത്തേഡിനായി, അത് ഇങ്ങനെയായിരിക്കും:
• kind: ഒരു സ്ട്രിംഗ്, 'method'.
• name: മെത്തേഡിൻ്റെ പേര് ഒരു സ്ട്രിംഗായി, ഉദാ., '#myMethod'.
• access: പ്രൈവറ്റ് അംഗത്തിൻ്റെ മൂല്യം വായിക്കാനോ എഴുതാനോ `get()`, `set()` ഫംഗ്ഷനുകളുള്ള ഒരു ഒബ്‌ജക്റ്റ്. പ്രൈവറ്റ് ഡെക്കറേറ്ററുകളുമായി പ്രവർത്തിക്കുന്നതിനുള്ള താക്കോൽ ഇതാണ്.
• private: ഒരു ബൂളിയൻ, `true`.
• static: മെത്തേഡ് സ്റ്റാറ്റിക് ആണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ബൂളിയൻ.
• addInitializer: ക്ലാസ് നിർവചിക്കുമ്പോൾ ഒരുതവണ പ്രവർത്തിക്കുന്ന ലോജിക് രജിസ്റ്റർ ചെയ്യാനുള്ള ഒരു ഫംഗ്ഷൻ.

ഒരു ലളിതമായ ലോഗിംഗ് ഡെക്കറേറ്റർ

ഒരു പ്രൈവറ്റ് മെത്തേഡ് വിളിക്കുമ്പോൾ ലോഗ് ചെയ്യുന്ന ഒരു അടിസ്ഥാന ഡെക്കറേറ്റർ നമുക്ക് ഉണ്ടാക്കാം. യഥാർത്ഥ മെത്തേഡ് വീണ്ടെടുക്കാൻ `context.access.get()` എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ ഉദാഹരണം വ്യക്തമാക്കുന്നു.

            
function logCall(target, context) {
  const methodName = context.name;

  // This decorator returns a new function that replaces the original method
  return function (...args) {
    console.log(`Calling private method: ${methodName}`);

    // Get the original method using the access object
    const originalMethod = context.access.get(this);

    // Call the original method with the correct 'this' context and arguments
    return originalMethod.apply(this, args);
  };
}

class DataService {
  @logCall
  #fetchData(url) {
    console.log(`   -> Fetching from ${url}...`);
    return { data: 'Sample Data' };
  }

  getUser() {
    return this.#fetchData('/api/user/1');
  }
}

const service = new DataService();
service.getUser();

// Console Output:
// Calling private method: #fetchData
//    -> Fetching from /api/user/1...

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, `@logCall` ഡെക്കറേറ്റർ `#fetchData` എന്നതിന് പകരം ഒരു പുതിയ ഫംഗ്ഷൻ നൽകുന്നു. ഈ പുതിയ ഫംഗ്ഷൻ ആദ്യം ഒരു സന്ദേശം ലോഗ് ചെയ്യുന്നു, തുടർന്ന് യഥാർത്ഥ `#fetchData` ഫംഗ്ഷനിലേക്ക് ഒരു റഫറൻസ് ലഭിക്കുന്നതിന് `context.access.get(this)` ഉപയോഗിക്കുന്നു, ഒടുവിൽ `.apply()` ഉപയോഗിച്ച് അതിനെ വിളിക്കുന്നു. യഥാർത്ഥ ഫംഗ്ഷനെ പൊതിയുന്ന ഈ രീതി മിക്ക ഡെക്കറേറ്റർ ഉപയോഗ കേസുകളുടെയും കേന്ദ്രമാണ്.

പ്രായോഗിക ഉപയോഗം 1: മെത്തേഡ് മെച്ചപ്പെടുത്തലും AOP-യും

ഡെക്കറേറ്ററുകളുടെ പ്രധാന ഉപയോഗങ്ങളിലൊന്ന്, പ്രധാന ലോജിക്കിനെ മലിനമാക്കാതെ ഒരു ആപ്ലിക്കേഷൻ്റെ പല ഭാഗങ്ങളെയും ബാധിക്കുന്ന പെരുമാറ്റങ്ങൾ—അതായത് ക്രോസ്-കട്ടിംഗ് കൺസേൺസ്—ചേർക്കുക എന്നതാണ്. ഇതാണ് ആസ്പെക്റ്റ്-ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗിൻ്റെ (AOP) സത്ത.

ഉദാഹരണം: @logExecutionTime ഉപയോഗിച്ച് പ്രകടനത്തിൻ്റെ സമയം അളക്കൽ

വലിയ തോതിലുള്ള ആപ്ലിക്കേഷനുകളിൽ, പ്രകടനത്തിലെ തടസ്സങ്ങൾ കണ്ടെത്തുന്നത് നിർണായകമാണ്. ഓരോ മെത്തേഡിലും ടൈമിംഗ് ലോജിക്ക് (`console.time`, `console.timeEnd`) സ്വമേധയാ ചേർക്കുന്നത് മടുപ്പിക്കുന്നതും പിശകുകൾക്ക് സാധ്യതയുള്ളതുമാണ്. ഒരു ഡെക്കറേറ്റർ ഇത് നിസ്സാരമാക്കുന്നു.

            
function logExecutionTime(target, context) {
  const methodName = context.name;

  return function (...args) {
    console.log(`Executing ${methodName}...`);
    const start = performance.now();

    const originalMethod = context.access.get(this);
    const result = originalMethod.apply(this, args);
    
    const end = performance.now();
    console.log(`Execution of ${methodName} finished in ${(end - start).toFixed(2)}ms.`);
    
    return result;
  };
}

class ReportGenerator {
  @logExecutionTime
  #processLargeDataset() {
    // Simulate a time-consuming operation
    let sum = 0;
    for (let i = 0; i < 100000000; i++) {
      sum += Math.sqrt(i);
    }
    return sum;
  }

  generate() {
    console.log('Starting report generation.');
    const result = this.#processLargeDataset();
    console.log('Report generation complete.');
    return result;
  }
}

const generator = new ReportGenerator();
generator.generate();

// Console Output:
// Starting report generation.
// Executing #processLargeDataset...
// Execution of #processLargeDataset finished in 150.75ms. (Time will vary)
// Report generation complete.

            

              
                Copy
              
            
          

ഒരൊറ്റ വരി, `@logExecutionTime` ഉപയോഗിച്ച്, നമ്മുടെ പ്രൈവറ്റ് മെത്തേഡിന് സങ്കീർണ്ണമായ പ്രകടന നിരീക്ഷണം ഞങ്ങൾ ചേർത്തു. ഈ ഡെക്കറേറ്റർ ഇപ്പോൾ നമ്മുടെ മുഴുവൻ കോഡ്ബേസിലുടനീളം, പബ്ലിക് അല്ലെങ്കിൽ പ്രൈവറ്റ്, ഏത് മെത്തേഡിലും പ്രയോഗിക്കാൻ കഴിയുന്ന ഒരു പുനരുപയോഗിക്കാവുന്ന ഉപകരണമാണ്.

ഉദാഹരണം: @memoize ഉപയോഗിച്ച് കാഷിംഗ്/മെമ്മോയിസേഷൻ

ഒരേ ഇൻപുട്ടിന് ഒരേ ഔട്ട്പുട്ട് നൽകുന്ന (അതായത്, പ്യുവർ ആയ) കമ്പ്യൂട്ടേഷണലി ചെലവേറിയ പ്രൈവറ്റ് മെത്തേഡുകൾക്ക്, ഫലങ്ങൾ കാഷ് ചെയ്യുന്നത് പ്രകടനം ഗണ്യമായി മെച്ചപ്പെടുത്തും. ഇതിനെ മെമ്മോയിസേഷൻ എന്ന് വിളിക്കുന്നു.

            
function memoize(target, context) {
  // Using WeakMap allows the class instance to be garbage collected
  const cache = new WeakMap();

  return function (...args) {
    if (!cache.has(this)) {
      cache.set(this, new Map());
    }
    const instanceCache = cache.get(this);
    const cacheKey = JSON.stringify(args);

    if (instanceCache.has(cacheKey)) {
      console.log(`[Memoize] Returning cached result for ${context.name}`);
      return instanceCache.get(cacheKey);
    }

    const originalMethod = context.access.get(this);
    const result = originalMethod.apply(this, args);
    instanceCache.set(cacheKey, result);

    console.log(`[Memoize] Caching new result for ${context.name}`);
    return result;
  };
}

class FinanceCalculator {
  @memoize
  #calculateComplexTax(income, region) {
    console.log('   -> Performing expensive tax calculation...');
    // Simulate a complex calculation
    for (let i = 0; i < 50000000; i++);
    return (income * 0.2) + (region === 'EU' ? 100 : 50);
  }

  getTaxFor(income, region) {
    return this.#calculateComplexTax(income, region);
  }
}

const calculator = new FinanceCalculator();

console.log('First call:');
calculator.getTaxFor(50000, 'EU');

console.log('\nSecond call (same arguments):');
calculator.getTaxFor(50000, 'EU');

console.log('\nThird call (different arguments):');
calculator.getTaxFor(60000, 'NA');

// Console Output:
// First call:
// [Memoize] Caching new result for #calculateComplexTax
//    -> Performing expensive tax calculation...
// 
// Second call (same arguments):
// [Memoize] Returning cached result for #calculateComplexTax
// 
// Third call (different arguments):
// [Memoize] Caching new result for #calculateComplexTax
//    -> Performing expensive tax calculation...

            

              
                Copy
              
            
          

ഓരോ തനതായ ആർഗ്യുമെൻ്റ് സെറ്റിനും ചെലവേറിയ കണക്കുകൂട്ടൽ എങ്ങനെ ഒരു തവണ മാത്രം പ്രവർത്തിക്കുന്നുവെന്ന് ശ്രദ്ധിക്കുക. പുനരുപയോഗിക്കാവുന്ന ഈ `@memoize` ഡെക്കറേറ്ററിന് ഇപ്പോൾ നമ്മുടെ ആപ്ലിക്കേഷനിലെ ഏത് പ്യുവർ പ്രൈവറ്റ് മെത്തേഡിനെയും സൂപ്പർചാർജ് ചെയ്യാൻ കഴിയും.

പ്രായോഗിക ഉപയോഗം 2: റൺടൈം വാലിഡേഷനും അസേർഷനുകളും

ഒരു ക്ലാസിൻ്റെ ആന്തരിക സമഗ്രത ഉറപ്പാക്കുന്നത് പരമപ്രധാനമാണ്. പ്രൈവറ്റ് മെത്തേഡുകൾ പലപ്പോഴും അവയുടെ ഇൻപുട്ടുകൾ സാധുവായ അവസ്ഥയിലാണെന്ന് അനുമാനിക്കുന്ന നിർണായക പ്രവർത്തനങ്ങൾ നിർവഹിക്കുന്നു. ഡെക്കറേറ്ററുകൾ ഈ അനുമാനങ്ങൾ, അല്ലെങ്കിൽ 'കരാറുകൾ', റൺടൈമിൽ നടപ്പിലാക്കാൻ ഒരു മികച്ച മാർഗം നൽകുന്നു.

ഉദാഹരണം: @validateInput ഉപയോഗിച്ച് ഇൻപുട്ട് പാരാമീറ്റർ വാലിഡേഷൻ

ഒരു പ്രൈവറ്റ് മെത്തേഡിലേക്ക് കൈമാറുന്ന ആർഗ്യുമെൻ്റുകൾ സാധൂകരിക്കുന്നതിന് ഒരു ഡെക്കറേറ്റർ ഫാക്ടറി—ഒരു ഡെക്കറേറ്റർ തിരികെ നൽകുന്ന ഒരു ഫംഗ്ഷൻ—നമുക്ക് ഉണ്ടാക്കാം. ഇതിനായി, നമ്മൾ ഒരു ലളിതമായ സ്കീമ ഉപയോഗിക്കും.

            
// Decorator Factory: a function that returns the actual decorator
function validateInput(schemaValidator) {
  return function(target, context) {
    const methodName = context.name;
    return function(...args) {
      if (!schemaValidator(args)) {
        throw new TypeError(`Invalid arguments for private method ${methodName}.`);
      }
      const originalMethod = context.access.get(this);
      return originalMethod.apply(this, args);
    }
  }
}

// A simple schema validator function
const userPayloadSchema = ([user]) => {
  return typeof user === 'object' &&
         user !== null &&
         typeof user.id === 'string' &&
         typeof user.email === 'string' &&
         user.email.includes('@');
};

class UserAPI {
  @validateInput(userPayloadSchema)
  #createSavePayload(user) {
    console.log('Payload is valid, creating DB object.');
    return { db_id: user.id, contact_email: user.email };
  }

  saveUser(user) {
    const payload = this.#createSavePayload(user);
    // ... logic to send payload to the database
    console.log('User saved successfully.');
  }
}

const api = new UserAPI();

// Valid call
api.saveUser({ id: 'user-123', email: 'test@example.com' });

// Invalid call
try {
  api.saveUser({ id: 'user-456', email: 'invalid-email' });
} catch (e) {
  console.error(e.message);
}

// Console Output:
// Payload is valid, creating DB object.
// User saved successfully.
// Invalid arguments for private method #createSavePayload.

            

              
                Copy
              
            
          

ഈ `@validateInput` ഡെക്കറേറ്റർ `#createSavePayload`-ൻ്റെ കരാറിനെ വ്യക്തവും സ്വയം നടപ്പിലാക്കുന്നതുമാക്കുന്നു. പ്രധാന മെത്തേഡ് ലോജിക്കിന് അതിൻ്റെ ഇൻപുട്ടുകൾ എല്ലായ്പ്പോഴും സാധുവാണെന്ന് ഉറപ്പുള്ളതുകൊണ്ട് വൃത്തിയായി നിലനിൽക്കാൻ കഴിയും. വലിയ, അന്തർദേശീയ ടീമുകളിൽ പ്രവർത്തിക്കുമ്പോൾ ഈ രീതി വളരെ ശക്തമാണ്, കാരണം ഇത് പ്രതീക്ഷകളെ നേരിട്ട് കോഡിൽ ഉൾക്കൊള്ളിക്കുന്നു, ഇത് ബഗുകളും തെറ്റിദ്ധാരണകളും കുറയ്ക്കുന്നു.

ഡെക്കറേറ്ററുകൾ ചെയിൻ ചെയ്യുന്നതും എക്സിക്യൂഷൻ ഓർഡറും

ഡെക്കറേറ്ററുകൾ സംയോജിപ്പിക്കുമ്പോൾ അവയുടെ ശക്തി വർദ്ധിക്കുന്നു. നിങ്ങൾക്ക് ഒരു മെത്തേഡിന് ഒന്നിലധികം ഡെക്കറേറ്ററുകൾ പ്രയോഗിക്കാൻ കഴിയും, അവയുടെ എക്സിക്യൂഷൻ ഓർഡർ മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.

നിയമം ഇതാണ്: ഡെക്കറേറ്ററുകൾ താഴെ നിന്ന് മുകളിലേക്ക് (bottom-up) വിലയിരുത്തപ്പെടുന്നു, എന്നാൽ തത്ഫലമായുണ്ടാകുന്ന ഫംഗ്ഷനുകൾ മുകളിൽ നിന്ന് താഴേക്ക് (top-down) എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു.

ലളിതമായ ലോഗിംഗ് ഡെക്കറേറ്ററുകൾ ഉപയോഗിച്ച് നമുക്ക് ഇത് വ്യക്തമാക്കാം:

            
function A(target, context) {
  console.log('Evaluated Decorator A');
  return function(...args) {
    console.log('Executed Wrapper A - Start');
    const original = context.access.get(this);
    const result = original.apply(this, args);
    console.log('Executed Wrapper A - End');
    return result;
  }
}

function B(target, context) {
  console.log('Evaluated Decorator B');
  return function(...args) {
    console.log('Executed Wrapper B - Start');
    const original = context.access.get(this);
    const result = original.apply(this, args);
    console.log('Executed Wrapper B - End');
    return result;
  }
}

class Example {
  @A
  @B
  #doWork() {
    console.log('   -> Core #doWork logic is running...');
  }

  run() {
    this.#doWork();
  }
}

console.log('--- Defining Class ---');
const ex = new Example();
console.log('\n--- Calling Method ---');
ex.run();

// Console Output:
// --- Defining Class ---
// Evaluated Decorator B
// Evaluated Decorator A
// 
// --- Calling Method ---
// Executed Wrapper A - Start
// Executed Wrapper B - Start
//    -> Core #doWork logic is running...
// Executed Wrapper B - End
// Executed Wrapper A - End

            

              
                Copy
              
            
          

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ക്ലാസ് നിർവചന സമയത്ത്, ഡെക്കറേറ്റർ B ആദ്യം വിലയിരുത്തി, തുടർന്ന് A. മെത്തേഡ് വിളിച്ചപ്പോൾ, A-യിൽ നിന്നുള്ള റാപ്പർ ഫംഗ്ഷൻ ആദ്യം പ്രവർത്തിച്ചു, അത് B-യിൽ നിന്നുള്ള റാപ്പറിനെ വിളിച്ചു, അത് ഒടുവിൽ യഥാർത്ഥ `#doWork` മെത്തേഡിനെ വിളിച്ചു. ഇത് ഒരു സമ്മാനം ഒന്നിലധികം പാളികളുള്ള പേപ്പറിൽ പൊതിയുന്നത് പോലെയാണ്; നിങ്ങൾ ആദ്യം ഏറ്റവും ഉള്ളിലെ പാളി (B) പ്രയോഗിക്കുന്നു, പിന്നെ അടുത്ത പാളി (A), എന്നാൽ നിങ്ങൾ അത് അഴിക്കുമ്പോൾ, നിങ്ങൾ ആദ്യം ഏറ്റവും പുറത്തുള്ള പാളി (A) നീക്കംചെയ്യുന്നു, പിന്നെ അടുത്തത് (B).

ആഗോള വീക്ഷണം: ആധുനിക വികസനത്തിന് ഇത് എന്തുകൊണ്ട് പ്രധാനമാണ്

ജാവാസ്ക്രിപ്റ്റ് പ്രൈവറ്റ് മെത്തേഡ് ഡെക്കറേറ്ററുകൾ സിൻ്റാക്റ്റിക് ഷുഗറിനേക്കാൾ ഉപരിയാണ്; അവ സ്കേലബിൾ, എൻ്റർപ്രൈസ്-ഗ്രേഡ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിലെ ഒരു സുപ്രധാന ചുവടുവെപ്പിനെ പ്രതിനിധീകരിക്കുന്നു. ഒരു ആഗോള ഡെവലപ്പർ കമ്മ്യൂണിറ്റിക്ക് ഇത് എന്തുകൊണ്ട് പ്രധാനമാണെന്നത് ഇതാ:

• മെച്ചപ്പെട്ട പരിപാലനം: കൺസേൺസിനെ വേർതിരിക്കുന്നതിലൂടെ, ഡെക്കറേറ്ററുകൾ കോഡ്ബേസുകളെക്കുറിച്ച് ചിന്തിക്കാൻ എളുപ്പമാക്കുന്നു. ടോക്കിയോയിലെ ഒരു ഡെവലപ്പർക്ക് ഒരു മെത്തേഡിൻ്റെ പ്രധാന ലോജിക്ക് മനസ്സിലാക്കാൻ കഴിയും, ബെർലിനിലെ ഒരു സഹപ്രവർത്തകൻ എഴുതിയ ലോഗിംഗ്, കാഷിംഗ്, അല്ലെങ്കിൽ വാലിഡേഷൻ എന്നിവയുടെ ബോയിലർപ്ലേറ്റിൽ നഷ്ടപ്പെടാതെ.
• മെച്ചപ്പെട്ട പുനരുപയോഗം: നന്നായി എഴുതിയ ഒരു ഡെക്കറേറ്റർ വളരെ പുനരുപയോഗിക്കാവുന്ന ഒരു കോഡ് ഭാഗമാണ്. ഒരൊറ്റ `@validate` അല്ലെങ്കിൽ `@logExecutionTime` ഡെക്കറേറ്റർ നൂറുകണക്കിന് കമ്പോണൻ്റുകളിൽ ഉടനീളം ഇറക്കുമതി ചെയ്യാനും ഉപയോഗിക്കാനും കഴിയും, ഇത് സ്ഥിരത ഉറപ്പാക്കുകയും കോഡ് ഡ്യൂപ്ലിക്കേഷൻ കുറയ്ക്കുകയും ചെയ്യുന്നു.
• സ്റ്റാൻഡേർഡ് ചെയ്ത കൺവെൻഷനുകൾ: വലിയ, വിതരണം ചെയ്യപ്പെട്ട ടീമുകളിൽ, കോഡിംഗ് സ്റ്റാൻഡേർഡുകളും ആർക്കിടെക്ചറൽ പാറ്റേണുകളും നടപ്പിലാക്കുന്നതിനുള്ള ശക്തമായ ഒരു സംവിധാനം ഡെക്കറേറ്ററുകൾ നൽകുന്നു. ഒരു ലീഡ് ആർക്കിടെക്റ്റിന് ആധികാരികത, ഫീച്ചർ ഫ്ലാഗിംഗ്, അല്ലെങ്കിൽ ഇൻ്റർനാഷണലൈസേഷൻ തുടങ്ങിയ കാര്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള അംഗീകൃത ഡെക്കറേറ്ററുകളുടെ ഒരു കൂട്ടം നിർവചിക്കാൻ കഴിയും, ഇത് ഓരോ ഡെവലപ്പറും ഈ സവിശേഷതകൾ സ്ഥിരവും പ്രവചിക്കാവുന്നതുമായ രീതിയിൽ നടപ്പിലാക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.
• ഫ്രെയിംവർക്ക്, ലൈബ്രറി ഡിസൈൻ: ഫ്രെയിംവർക്കുകളുടെയും ലൈബ്രറികളുടെയും രചയിതാക്കൾക്ക്, ഡെക്കറേറ്ററുകൾ ഒരു വൃത്തിയുള്ള, ഡിക്ലറേറ്റീവ് API നൽകുന്നു. ഇത് ലൈബ്രറിയുടെ ഉപയോക്താക്കൾക്ക് ലളിതമായ `@` സിൻ്റാക്സ് ഉപയോഗിച്ച് സങ്കീർണ്ണമായ സ്വഭാവങ്ങൾ തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുന്നു, ഇത് കൂടുതൽ അവബോധജന്യവും ആസ്വാദ്യകരവുമായ ഡെവലപ്പർ അനുഭവത്തിലേക്ക് നയിക്കുന്നു.

ഉപസംഹാരം: ക്ലാസ്-ബേസ്ഡ് പ്രോഗ്രാമിംഗിൻ്റെ ഒരു പുതിയ യുഗം

ജാവാസ്ക്രിപ്റ്റ് പ്രൈവറ്റ് മെത്തേഡ് ഡെക്കറേറ്ററുകൾ ക്ലാസുകളുടെ ആന്തരിക സ്വഭാവം വർദ്ധിപ്പിക്കുന്നതിന് സുരക്ഷിതവും മനോഹരവുമായ ഒരു മാർഗം നൽകുന്നു. എൻക്യാപ്‌സുലേഷൻ്റെയും സിംഗിൾ റെസ്പോൺസിബിലിറ്റിയുടെയും പ്രധാന തത്വങ്ങളിൽ വിട്ടുവീഴ്ച ചെയ്യാതെ, എഒപി, മെമ്മോയിസേഷൻ, റൺടൈം വാലിഡേഷൻ തുടങ്ങിയ ശക്തമായ പാറ്റേണുകൾ നടപ്പിലാക്കാൻ അവ ഡെവലപ്പർമാരെ പ്രാപ്തരാക്കുന്നു.

ക്രോസ്-കട്ടിംഗ് കൺസേൺസിനെ പുനരുപയോഗിക്കാവുന്ന, ഡിക്ലറേറ്റീവ് ഡെക്കറേറ്ററുകളിലേക്ക് സംഗ്രഹിക്കുന്നതിലൂടെ, നമുക്ക് കൂടുതൽ ശക്തമായതും മാത്രമല്ല, വായിക്കാനും പരിപാലിക്കാനും സ്കെയിൽ ചെയ്യാനും വളരെ എളുപ്പമുള്ളതുമായ സിസ്റ്റങ്ങൾ നിർമ്മിക്കാൻ കഴിയും. ഡെക്കറേറ്ററുകൾ ജാവാസ്ക്രിപ്റ്റ് ഭാഷയുടെ ഒരു പ്രാദേശിക ഭാഗമാകുമ്പോൾ, അവ ലോകമെമ്പാടുമുള്ള പ്രൊഫഷണൽ ഡെവലപ്പർമാർക്ക് ഒഴിച്ചുകൂടാനാവാത്ത ഒരു ഉപകരണമായി മാറുമെന്നതിൽ സംശയമില്ല, ഇത് ഒബ്ജക്റ്റ്-ഓറിയൻ്റഡ്, കമ്പോണൻ്റ്-ബേസ്ഡ് ഡിസൈനിൽ ഒരു പുതിയ തലത്തിലുള്ള സങ്കീർണ്ണതയും വ്യക്തതയും സാധ്യമാക്കുന്നു.

ഇന്ന് അവ ഉപയോഗിക്കാൻ നിങ്ങൾക്ക് ബാബേൽ പോലുള്ള ഒരു ഉപകരണം ഇപ്പോഴും ആവശ്യമായി വന്നേക്കാം, എന്നാൽ ഈ പരിവർത്തനപരമായ സവിശേഷത പഠിക്കാനും പരീക്ഷിക്കാനും തുടങ്ങാനുള്ള ഏറ്റവും അനുയോജ്യമായ സമയമാണിത്. വൃത്തിയുള്ളതും ശക്തവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ ജാവാസ്ക്രിപ്റ്റ് ക്ലാസുകളുടെ ഭാവി ഇവിടെയുണ്ട്, അത് അലങ്കരിക്കപ്പെട്ടിരിക്കുന്നു.